﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Databas;

namespace Logik
{
    public class Logikhantering
    {
        
        public Anstallda anstallda = new Anstallda();
        public Behorigheter behorighet = new Behorigheter();
        public List<Anstallda> ListaMedHittadAnstalld = new List<Anstallda>();
        public List<Forsakring> ListaMedHittadForetagsForsakring = new List<Forsakring>();
        public List<Forsakring> ListaMedHittadOvrigPersonForsakring = new List<Forsakring>();
        public List<Forsakring> listans = new List<Forsakring>();
        public List<Forsakring> listan = new List<Forsakring>();
        public List<Forsakring> lista = new List<Forsakring>();


        public string inloggAnvandare;
        public string InloggAnvandare
        {
            get { return inloggAnvandare; }
            set { inloggAnvandare = value; }
        }
      
        public Int64 id;
        public Int64 ID
        {
            get { return id; }
            set { id = value; }
        }

        //Skapara åtkomst till databasen
        private Databashantering databashantering = new Databashantering();        

        public Logikhantering()
        {
           
        }
        string abc;
        public double sumBarn;
        public double sumVuxen;
        public double summaackvarden;
        public double provisionSO;
        public double sumSjukOchOlycka, sumSjukOchOlycka1;
        public double sumSjukskrivning, sumSjukskrivning1;
        public double sumLiv, sumLiv1;
        public double sumLivVuxen;
        public double provisionLiv;
        public double provionOvrig;
        public double semesterersattning;
        public string semesterprocent;
        public double summaprov;
        public double skatt;
        public double anstalldskattesats;
        public double attUtbetala;
        
        
        
        #region//Anställd funktioner
        //Ger behörighet
        public Int64 geBehöright(Int64 personnummer)
        {
            Anstalld behorighet = databashantering.hamtaBehorighetsId(personnummer);
            if (behorighet != null)
            {
                Int64 behorighetsid = (behorighet.behorighetsID);
                id = behorighetsid;
                return behorighet.behorighetsID;
            }
            return 3000;
        }
        //Inloggad anvandare sparas i databasen
        public string HittaInloggadAnvändare(int agenturId)
        {
            Anstalld a = databashantering.HamtaAnstalldViaAgentNr(agenturId);

            string fornamn = a.fNamn.ToString() + " " + a.eNamn.ToString();
            InloggAnvandare = fornamn;


            return fornamn;
        }
        #endregion

        #region//Lägga till

        //Lägger till provision
        public void LaggaTillProvision(DateTime kalenderar, decimal totMin, decimal totMax, decimal andelVuxen, decimal andelBarn)
        {
            databashantering.addProvision(kalenderar, andelBarn, andelVuxen, totMin, totMax);
        }
        //Lägger till grundbelopp
        public void LaggatillGrundbelopp(string forsakringstyp, DateTime datum, decimal grundbelopp, decimal ackvarde)
        {
            databashantering.addGrundbelopp(forsakringstyp, datum, grundbelopp, ackvarde);
        }
        
        //lägger till anställda
        public void laggatillAnstalld(string forNamn, string efterNamn, Int64 personNummer, string adress, int postNummer, int teleNummer,
            string ort, string teleTyp, int agenturNummer, decimal skattesats, string befattning, string losenord, string epost, int behorighetsID)
        {
            databashantering.addAnstalld(forNamn, efterNamn, personNummer, adress, postNummer, teleNummer, ort, teleTyp, agenturNummer, skattesats, befattning, losenord, epost, behorighetsID);
        }
        //Lägger till personförsäkringar
        public void laggaTillPersonforsakring(string efterNamn, string forNamn, Int64 personNr, string adress, int postNr, string ort, Int64 telefonHem,
            Int64 telefonArbete, string ePost, string fefterNamn, string fforNamn, Int64 fpersonNr, DateTime ankomstDatum, string forsakringsTyp,
            string sjukOlycksfallTillval, string livsForsakringTillval, decimal livsForsakringsGrundbelopp, string sjukSkrivningsTillval,
            string betalningsform, decimal grundbelopp, int agenturNr, decimal sjukskrivGrundbelopp, decimal sjukolycksGrundbelopp, string ftypen)
        {
            databashantering.addPersonForsakring(efterNamn, forNamn, personNr, adress, postNr, ort, telefonHem, telefonArbete, ePost, fefterNamn, fforNamn, fpersonNr, 
                ankomstDatum, forsakringsTyp, sjukSkrivningsTillval, livsForsakringTillval, livsForsakringsGrundbelopp, sjukSkrivningsTillval, betalningsform, grundbelopp, 
                agenturNr, sjukskrivGrundbelopp, sjukolycksGrundbelopp, ftypen);        
        }        
        //lägger till övriga försäkringar
        public void laggatillOvrigForsakring(string efterNamn, string forNamn, Int64 personNr, string foretagsNamn,
          Int64 orgNr, string adress, string ort, int postNr, Int64 telefonHem, Int64 telefonArbete, string ePost,
          string fefterNamn, string fforNamn, Int64 fpersonNr, Int64 premie, string tabell, string betalningsform, int agentNr, string ftypen)
        {
            databashantering.addOvrigpersonForsakring(efterNamn, forNamn, personNr, foretagsNamn, orgNr, adress, ort, postNr, telefonHem, telefonArbete,
                ePost, fefterNamn, fforNamn, fpersonNr, premie, tabell, betalningsform, agentNr, ftypen);
        }
        //Lägger till företagsförsäkring
        public void laggatillForetagForsakring(string namn, Int64 orgNr, string kontaktperson, string adress, int postNr, string ort, Int64 teleNr, Int64 faxNr, string forsakringsBolag,
            string forsakringsTyp, string betalningsPeriod, DateTime begynnelseDatum, DateTime forfalloDag, Int64 fPremie, int agenturNr, string anteckning, string ftypen, string epost)
        {
            databashantering.addForetagsForsakring(namn, orgNr, kontaktperson, adress, postNr, ort, teleNr, faxNr, forsakringsBolag, forsakringsTyp, betalningsPeriod,
                begynnelseDatum, forfalloDag, fPremie, agenturNr, anteckning, ftypen, epost);
        }
        //Sparar behörighet för vald anställd
        public void sparaBehorighet(int agenturnummer, int behorighet)
        {

            Anstalld a = databashantering.HamtaAnstalldViaAgentNr(agenturnummer);

            databashantering.addBehorighet(a.personNr, behorighet);
        }

        
        //Sparar en tecknad försäkring i företag
        public void TecknadforsakringForetagSpara(Int64 lopNr, string forsakringsnr, DateTime betald, decimal provison, string betalad)
        {
            databashantering.uppdateraTecknadforsakringForetag(lopNr, betald, forsakringsnr, provison, betalad);
        }
        //Sparar en tecknad försäkring i övriga och person
        public void TecknadForsakringsSpara(Int64 lopNr, string forsakringsnr, DateTime betald, decimal grundbelopp, decimal
            sjukolycksfallgrundbelopp, decimal sjukskrivgrundbelopp, decimal livgrundbelopp, string betalad, decimal provision)
        {
            databashantering.uppdateraTecknadforsakringPersonOvrigt(lopNr, betald, forsakringsnr, grundbelopp, sjukolycksfallgrundbelopp,
                sjukskrivgrundbelopp, livgrundbelopp, betalad, provision);
        }

        #endregion

        #region//Hämta uppgifter
        //Hämta anställd via personnr
        public Int64 HämtaAnställdPersNr(int agenturId)
        {
            Anstalld a = databashantering.HamtaAnstalldViaAgentNr(agenturId);
            Int64 personnummer = Convert.ToInt64(a.personNr);

            return personnummer;
        }
        //Hämtar lösenord för en anstäld
        public string hamtaHamtalösen(long persnr)
        {
            string aq = databashantering.Hamtalösen(persnr);
            return aq;

        }
        //Hämtar alla anställda
        public List<Anstalld> HamtaAllaAnstallda()
        {
            //Skapar en lista av anstallda för att retunera
            List<Anstalld> anstalld = new List<Anstalld>();

            //Hämta anstallda från databasen
            List<Anstalld> dbanstalld = databashantering.HamtaAllaAnstallda();

            //Laddar in anstallda i listan
            foreach (Anstalld a in dbanstalld)
            {
                anstalld.Add(a);
            }

            return anstalld;
        }
        //Hämtar alla företagförsäkringar
        public List<Forsakring> HamtaForetag()
        {
            //Skapar en lista av företagförsäkringar för att retunera
            List<Forsakring> Foretag = new List<Forsakring>();

            //Hämta företagförsäkringar från databasen
            List<Forsakring> dbOvrigPersoner = databashantering.HamtaForetag();

            //Laddar in företagförsäkringar i listan
            foreach (Forsakring a in dbOvrigPersoner)
            {
                Foretag.Add(a);
            }

            return Foretag;
        }
        //Hämtar all kundprospekt
        public List<Forsakring> HamtaKundprospekt()
        {
            //Skapar en lista av övrigapersoner för att retunera
            List<Forsakring> kundpros = new List<Forsakring>();

            //Hämta övrigapersoner från databasen
            List<Forsakring> kund = databashantering.HamtaKundprospekt();

            //Laddar in övrigapersoner i listan
            foreach (Forsakring a in kund)
            {
                kundpros.Add(a);
            }

            return kundpros;
        }

        //Hämtar alla övrigaförsäkringar
        public List<Forsakring> HamtaOvrigPerson()
        {
            //Skapar en lista av övrigapersoner för att retunera
            List<Forsakring> OvrigPersoner = new List<Forsakring>();

            //Hämta övrigapersoner från databasen
            List<Forsakring> dbOvrigPersoner = databashantering.HamtaOvrigPerson();

            //Laddar in övrigapersoner i listan
            foreach (Forsakring a in dbOvrigPersoner)
            {
                OvrigPersoner.Add(a);
            }

            return OvrigPersoner;
        }

        public List<Forsakring> HamtaAllaPersonForsakring()
        {
            //Skapar en lista av personförsäkringar för att retunera
            List<Forsakring> person = new List<Forsakring>();

            //Hämta personförsäkring från databasen
            List<Forsakring> dbanstalld = databashantering.HamtaPersonForsakring();

            //Laddar in personförsäkringar i listan
            foreach (Forsakring a in dbanstalld)
            {
                person.Add(a);
            }

            return person;
        }
        // TILL TFlistview
        public List<Forsakring> HamtaAllaPersonOchOvrigt()
        {
            //Skapar en lista av personförsäkringar för att retunera
            List<Forsakring> person = new List<Forsakring>();

            //Hämta personförsäkring från databasen
            List<Forsakring> dbanstalld = databashantering.HamtaPersonOchOvrig();

            //Laddar in personförsäkringar i listan
            foreach (Forsakring a in dbanstalld)
            {
                person.Add(a);
            }

            return person;
        }
        //Hämtar alla grundbelopp för tillval sjuk & olycksfall
        public List<ForsakringsUtbud> HamtaGrundbeloppTillvalSjuk()
        {
            List<ForsakringsUtbud> grunduppgifter = new List<ForsakringsUtbud>();

            List<ForsakringsUtbud> dbgrunduppgift = databashantering.HamtarGrundBeloppTillTillvalSjuk();

            foreach (ForsakringsUtbud r in dbgrunduppgift)
            {
                grunduppgifter.Add(r);
            }

            return grunduppgifter;
        }
        //Hämtar alla grundbelopp för tillval sjukersättning
        public List<ForsakringsUtbud> HamtaGrundbeloppTillvalSjukErsattnig()
        {
            List<ForsakringsUtbud> grunduppgifter = new List<ForsakringsUtbud>();

            List<ForsakringsUtbud> dbgrunduppgift = databashantering.HamtarGrundBeloppTillTillvalSjukErsattning();

            foreach (ForsakringsUtbud r in dbgrunduppgift)
            {
                grunduppgifter.Add(r);
            }

            return grunduppgifter;
        }
        //Hämtar alla grundbelopp för livsförsäkring
        public List<ForsakringsUtbud> HamtaGrundbeloppTillLivsF()
        {
            List<ForsakringsUtbud> grunduppgifter = new List<ForsakringsUtbud>();

            List<ForsakringsUtbud> dbgrunduppgift = databashantering.HamtarGrundBeloppTillLivsF();

            foreach (ForsakringsUtbud r in dbgrunduppgift)
            {
                grunduppgifter.Add(r);
            }

            return grunduppgifter;
        }
        //Hämtar alla grundbelopp för vuxenförsäkring
        public List<ForsakringsUtbud> HamtaGrundbeloppTillVuxenF()
        {
            List<ForsakringsUtbud> grunduppgifter = new List<ForsakringsUtbud>();

            List<ForsakringsUtbud> dbgrunduppgift = databashantering.HamtarGrundBeloppTillVuxenF();

            foreach (ForsakringsUtbud r in dbgrunduppgift)
            {
                grunduppgifter.Add(r);
            }

            return grunduppgifter;
        }
        //Hämtar alla grundbelopp för barnförsäkring
        public List<ForsakringsUtbud> HamtaGrundbeloppTillBarnF()
        {
            List<ForsakringsUtbud> grunduppgifter = new List<ForsakringsUtbud>();

            List<ForsakringsUtbud> dbgrunduppgift = databashantering.HamtarGrundBeloppTillBarnF();

            foreach (ForsakringsUtbud r in dbgrunduppgift)
            {
               grunduppgifter.Add(r);
            }

            return grunduppgifter;
        }
        //Söker på försäkringstyp till grundbelopp för att visa senare
        public List<ForsakringsUtbud> HamtaGrunduppgifterviaFtyp(string forsakringstyp)
        {
            List<ForsakringsUtbud> grunduppgifter = new List<ForsakringsUtbud>();

            List<ForsakringsUtbud> dbgrunduppgift = databashantering.HamtaAnstalldViaforsakringstyp(forsakringstyp);
            
            foreach (ForsakringsUtbud r in dbgrunduppgift)
                {
                    grunduppgifter.Add(r);
                }

            return grunduppgifter;
        }
        //Hämtar all provision
        public List<Provision> HamtaProvision() 
        {
            List<Provision> prov = new List<Provision>();

            List<Provision> Hamtaprov = databashantering.HamtaProvision();

            foreach (Provision r in Hamtaprov)
            {
                prov.Add(r);
            }

            return prov;
        }
        #endregion

        #region//Sök funktioner
        //Sök anställd
        public void sokAnstalld(string varde)
        {
            ListaMedHittadAnstalld.Clear();
            try
            {
                int convert = Convert.ToInt32(varde);
                List<Anstalld> ans = databashantering.SokAnstalldViaAgentNr(convert);

                foreach (Anstalld r in ans)
                {
                    AnstalldPostNr ansp = databashantering.SokAnstalldViaPersNr(r.personNr);
                    AnstalldTelefon anst = databashantering.SokAnstalldViaTeleNr(r.personNr);
                    Anstallda a = new Anstallda(r.fNamn, r.eNamn, r.personNr, r.gatuadress, r.postNr, ansp.ort, anst.teleNr, anst.typ, r.agenturNr, (float)r.skattesats, r.befattning, r.losenord, r.epost);
                    ListaMedHittadAnstalld.Add(a);
                }
            }
            catch { }
            try
            {
                List<Anstalld> ans2 = databashantering.SokAnstalldViaENamn(varde);
                foreach (Anstalld r in ans2)
                {
                    AnstalldPostNr ansp = databashantering.SokAnstalldViaPersNr(r.personNr);
                    if (ansp.ort == null){ ansp.ort = ""; }                    
                    AnstalldTelefon anst = databashantering.SokAnstalldViaTeleNr(r.personNr);
                    Anstallda a = new Anstallda(r.fNamn, r.eNamn, r.personNr, r.gatuadress, r.postNr, ansp.ort, anst.teleNr, anst.typ, r.agenturNr, (float)r.skattesats, r.befattning, r.losenord, r.epost);
                    ListaMedHittadAnstalld.Add(a);
                }
            }
            catch { }
        }        
        //Sök företag
        public void sokForetag(string varde)
        {
            ListaMedHittadForetagsForsakring.Clear();
            try
            {
                List<Forsakring> foretagforsakrad = databashantering.SokForetagViaNamn(varde);
                foreach (Forsakring t in foretagforsakrad)
                {
                    ListaMedHittadForetagsForsakring.Add(t);
                }

                 Int64 convert = Convert.ToInt64(varde);
                 List<Forsakring> agnr = databashantering.SokForetagViaAgnr(convert);

                 foreach (Forsakring r in agnr)
                {
                    ListaMedHittadForetagsForsakring.Add(r);
                }


                 List<Forsakring> fore = databashantering.SokForetagViaOrgnr(convert);

                 foreach (Forsakring r in fore)
                {
                    ListaMedHittadForetagsForsakring.Add(r);
                }
            }
            catch { }
          
        }
        //SokpersonForsakring
        public void SokPersonForsakring(string varde)
        {
            lista.Clear();
            try
            {

                List<Forsakring> Ffnamn = databashantering.SokPersonForsakringViaFeNamn(varde);
                foreach (Forsakring r in Ffnamn)
                {
                    lista.Add(r);
                }

                List<Forsakring> fnamn = databashantering.SokPersonForsakringViafNamn(varde);
                foreach (Forsakring r in fnamn)
                {
                    lista.Add(r);
                }

                List<Forsakring> enamn = databashantering.SokPersonForsakringViaEnamn(varde);
                foreach (Forsakring r in enamn)
                {
                    lista.Add(r);
                }

                Int64 convert = Convert.ToInt64(varde);
                List<Forsakring> forsak = databashantering.SokPersonForsakringViaPersonNr(convert);
                foreach (Forsakring r in forsak)
                {
                    lista.Add(r);
                }
                List<Forsakring> hej = databashantering.SokPersonForsakringViaFPersonNr(convert);
                foreach (Forsakring r in hej)
                {
                    lista.Add(r);
                }

                List<Forsakring> agnr = databashantering.SokPersonForsakringViaAgnr(convert);
                foreach (Forsakring r in agnr)
                {
                    lista.Add(r);
                }
            }
            catch { }
        }
        //SokOvrig
        public void sokOvrigPerson(string varde)
        {
            ListaMedHittadOvrigPersonForsakring.Clear();

            try
            {

                List<Forsakring> fnamn = databashantering.SokOvrigViaFNamn(varde);
                foreach (Forsakring er in fnamn)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(er);
                }
                List<Forsakring> enamn = databashantering.SokOvrigViafeNamn(varde);
                foreach (Forsakring er in enamn)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(er);
                }
                List<Forsakring> s = databashantering.SokOvrigViaeNamn(varde);
                foreach (Forsakring er in s)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(er);
                }
                List<Forsakring> f = databashantering.SokOvrigForetagViaFNamn(varde);
                foreach (Forsakring er in f)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(er);
                }

                Int64 convert = Convert.ToInt64(varde);
                List<Forsakring> fore = databashantering.SokOvrigViaOrgNr(convert);
                foreach (Forsakring r in fore)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(r);
                }
                List<Forsakring> pers = databashantering.SokOvrigViaPersonNr(convert);
                foreach (Forsakring r in pers)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(r);
                }
                List<Forsakring> fpersonnr = databashantering.SokOvrigViaFpersonNr(convert);
                foreach (Forsakring r in fpersonnr)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(r);
                }
                List<Forsakring> agnr = databashantering.SokOvrigForsakringViaAgnr(convert);
                foreach (Forsakring r in agnr)
                {
                    ListaMedHittadOvrigPersonForsakring.Add(r);
                }



            }
            catch
            { }

        }
        //Sok Tecknadförsäkring personförsäkring
        public void SokTF(string varde)
        {
            listan.Clear();
            try
            {
                Int64 convert = Convert.ToInt64(varde);
                List<Forsakring> forsak = databashantering.SokTF(convert);

                foreach (Forsakring r in forsak)
                {
                    listan.Add(r);
                }
            }
            catch { }
        }
        //SokTecknadförsäkringforetag
        public void SokTForg(string varde)
        {
            listans.Clear();
            try
            {
                Int64 convert = Convert.ToInt64(varde);
                List<Forsakring> forsak = databashantering.SokTFOrgNr(convert);

                foreach (Forsakring r in forsak)
                {
                    listans.Add(r);
                }
            }
            catch { }
        }

        #endregion

        #region//Tabort
        public void TaBortProvision(int provId)
        {
            databashantering.RemoveProvision(provId);
        }
        //Funktion för att se om en parsning lyckades
        public bool IntParseLyckades(string[] b)
        {
            int lyckades;

            foreach (string a in b)
            {
                if (!int.TryParse(a, out lyckades))
                {
                    return false;
                }
            }
            return true;
        }
        //Funktion för att se om en parseing lyckades
        public bool LongParseLyckades(string[] b)
        {
            long lyckades;

            foreach (string a in b)
            {
                if (!long.TryParse(a, out lyckades))
                {
                    return false;
                }
            }
            return true;
        }
        //Funktion för att se om en parsning lyckades
        public bool DecimalParseLyckades(string[] b)
        {
            decimal lyckades;

            foreach (string a in b)
            {
                if (!decimal.TryParse(a, out lyckades))
                {
                    return false;
                }
            }
            return true;
        }
        //Logga ut funktion
        public void LoggaUt()
        {
            inloggAnvandare = null;
        }
        //Tar bort ett grundbelopp
        public void taBortGrundbelopp(int grunddataid)
        {
            databashantering.RemoveGrundbelopp(grunddataid);
        }       
        //Tar bort en anställd
        public void taBortAnställd(long personnummer)
        {
            databashantering.removeAnstalld(personnummer);
        }
        //Tar bort en övrig person
        public void taBortOvrigPerson(int ftagareID)
        {
            databashantering.removeOvrigPerson(ftagareID);
        }
        //Tar bort en personförsäkring
        public void taBortPersonForsakring(int ftagareID)
        {
            databashantering.removePersonForsakring(ftagareID);
        }
        //Tar bort en företagsförsäkring
        public void taBortForetagsForsakring(int ftagareID)
        {
            databashantering.removeForetagsForsakring(ftagareID);
        }
        #endregion

        #region//Uppdatera
        //Uppdaterar en anställd
        public void uppdateraAnstalld(string forNamn, string efterNamn, Int64 personNummer, string adress, int postNummer, Int64 teleNummer,
            string ort, string teleTyp, int agenturNummer, decimal skattesats, string befattning, string losenord, string epost, int behorighetsID)
        {
            databashantering.uppdateraAnstalld(forNamn, efterNamn, personNummer, adress, postNummer, teleNummer, ort, teleTyp, agenturNummer, 
                skattesats, befattning, losenord, epost, behorighetsID);
        }
        //Uppdaterar en personförsäkring
        public void uppdateraPersonForsakrin(string efterNamn, string forNamn, Int64 personNr, string adress, int postNr, string ort, Int64 telefonHem,
            Int64 telefonArbete, string ePost, string fefterNamn, string fforNamn, Int64 fpersonNr, DateTime ankomstDatum, string forsakringsTyp,
            string sjukOlycksfallTillval, string livsForsakringTillval, decimal livsForsakringsGrundbelopp, string sjukSkrivningsTillval,
            string betalningsform, decimal grundbelopp, int agenturNr, decimal sjukskrivGrundbelopp, decimal sjukolycksGrundbelopp, int ftagareID)
        {
            databashantering.uppdateraPersonforsakringar(efterNamn, forNamn, personNr, adress, postNr, ort, telefonHem, telefonArbete, ePost, fefterNamn,
                fforNamn, fpersonNr, ankomstDatum, forsakringsTyp, sjukOlycksfallTillval, livsForsakringTillval, livsForsakringsGrundbelopp,
                sjukSkrivningsTillval, betalningsform, grundbelopp, agenturNr, sjukskrivGrundbelopp, sjukolycksGrundbelopp, ftagareID);
        }
        //Uppdaterar en övrigpersonförsäkring
        public void uppdateraOvrigPerson(string efterNamn, string forNamn, Int64 personNr, string foretagsNamn,
          Int64 orgNr, string adress, string ort, int postNr, int telefonHem, int telefonArbete, string ePost,
          string fefterNamn, string fforNamn, Int64 fpersonNr, int premie, string tabell, string betalningsform, int agenturNr, int ftagareID)
        {
            databashantering.uppdateraOvrigPersonforsakring(efterNamn, forNamn, personNr, foretagsNamn, orgNr, adress, ort, postNr, telefonHem,
                telefonArbete, ePost, fefterNamn, fforNamn, fpersonNr, premie, tabell, betalningsform, agenturNr, ftagareID);
        }
        //Uppdaterar en företagsförsäkring
        public void uppdateraForetagsForsakring(string namn, Int64 orgNr, string kontaktperson, string adress, int postNr, string ort,
            int teleNr, int faxNr, string forsakringsBolag, string forsakringsTyp, string betalningsPeriod, DateTime begynnelseDatum,
            DateTime forfalloDag, int fPremie, string anteckning, int agenturNr, int ftagareID, string epost)
        {
            databashantering.uppdateraForetagForsakring(namn, orgNr, kontaktperson, adress, postNr, ort, teleNr, faxNr, forsakringsBolag, forsakringsTyp,
                betalningsPeriod, begynnelseDatum, forfalloDag, fPremie, anteckning, agenturNr, ftagareID, epost);
        }
        //Uppdaterar ett grundbelopp
        public void uppdateraGrundbelopp(int grunddataid, string forsakringstyp, DateTime datum, Int64 grundbelopp, Int64 ackvarde)
        {
            databashantering.UppdateraGrundbelopp(grunddataid, forsakringstyp, datum, grundbelopp, ackvarde);
        }
        //Uppdaterar utskriftsdatum
        public void uppdateraUtskrifsdatum(int personnr, DateTime utskrifsdatum)
        {
            databashantering.uppdateraUtskriftsdatum(personnr, utskrifsdatum);
        }
        //Uppdaterar en provision
        public void UppdateraProvision(int provid, DateTime kalenderar, decimal totMin, decimal totMax, decimal andelBarn, decimal andelVuxna)
        {
            databashantering.UppdateraProv(provid, kalenderar, totMin, totMax, andelBarn, andelVuxna);
        }

        #endregion
        
        //Räknar provision
        public void raknaUtProvision(int agenturNr, DateTime frandatum, DateTime tilldatum)
        {
            abc = DateTime.Now.Year.ToString();
            List<Forsakring> f = databashantering.HamtaForsakringar(agenturNr, frandatum, tilldatum);
            List<Provision> p = databashantering.hamtaProvisioner();

            foreach (Forsakring r in f)
            {
                ForsakringsUtbud fu = databashantering.hamtaAckvarde(r.fTyp, (decimal)r.grundbelopp);
                if (!string.IsNullOrEmpty(fu.forsakringsTyp))
                {
                    //if (fu.forsakringsTyp == "Sjuk- och olycksfallförsäkring för barn")
                    //{
                    //    sumBarn = sumBarn + (double)fu.ackvarde;
                    //}

                    //
                    if (!string.IsNullOrEmpty(fu.forsakringsTyp) && fu.forsakringsTyp == "Sjuk- och olycksfallförsäkring för barn")
                    {
                        if (r.sjukOcholycksfall == "Yes")
                        {
                            if (abc == "2012")
                            {
                                sumSjukOchOlycka1 = sumSjukOchOlycka1 + (((double)r.sjukolycksgrundbelopp) * 0.015);
                            }
                            if (abc == "2013")
                            {
                                sumSjukOchOlycka1 = sumSjukOchOlycka1 + (((double)r.sjukolycksgrundbelopp) * 0.0155);
                            }
                        }
                        if (r.sjukskrivning == "Yes")
                        {
                            if (abc == "2012")
                            {
                                sumSjukskrivning1 = sumSjukskrivning1 + (((double)r.sjukskrivgrundbelopp) * 1.54);
                            }
                            if (abc == "2013")
                            {
                                sumSjukskrivning1 = sumSjukskrivning1 + (((double)r.sjukskrivgrundbelopp) * 1.56);
                            }
                        }
                        if (r.hojningLiv == "Yes")
                        {
                            if (abc == "2012")
                            {
                                sumLiv1 = sumLiv1 + (((double)r.livgrundbelopp) * 0.005);
                            }
                            if (abc == "2013")
                            {
                                sumLiv1 = sumLiv1 + (((double)r.livgrundbelopp) * 0.005);
                            }
                        }
                        sumBarn = sumBarn+ (double)fu.ackvarde + sumLiv1 + sumSjukOchOlycka1 + sumSjukskrivning1;
                    }
                    //
                    if (!string.IsNullOrEmpty(fu.forsakringsTyp) && fu.forsakringsTyp == "Sjuk- och olycksfallsförsäkring för vuxen")
                    {
                        if (r.sjukOcholycksfall == "Yes")
                        {
                            if (abc == "2012")
                            {
                                sumSjukOchOlycka = sumSjukOchOlycka + (((double)r.sjukolycksgrundbelopp) * 0.015);
                            }
                            if (abc == "2013")
                            {
                                sumSjukOchOlycka = sumSjukOchOlycka + (((double)r.sjukolycksgrundbelopp) * 0.0155);
                            }
                        }
                        if (r.sjukskrivning == "Yes")
                        {
                            if (abc == "2012")
                            {
                                sumSjukskrivning = sumSjukskrivning + (((double)r.sjukskrivgrundbelopp) * 1.54);
                            }
                            if (abc == "2013")
                            {
                                sumSjukskrivning = sumSjukskrivning + (((double)r.sjukskrivgrundbelopp) * 1.56);
                            }
                        }
                        if (r.hojningLiv == "Yes")
                        {
                            if (abc == "2012")
                            {
                                sumLiv = sumLiv + (((double)r.livgrundbelopp) * 0.005);
                            }
                            if (abc == "2013")
                            {
                                sumLiv = sumLiv + (((double)r.livgrundbelopp) * 0.005);
                            }
                        }
                        sumVuxen = sumVuxen + (double)fu.ackvarde + sumLiv + sumSjukOchOlycka + sumSjukskrivning;
                    }
                }
                if (fu.forsakringsTyp == "Livförsäkring vuxen")
                {
                    sumLivVuxen = sumLivVuxen + ((double)fu.ackvarde);

                    if (abc == "2012")
                    {
                        provisionLiv = sumLivVuxen * (1 - 0.107);
                    }
                    if (abc == "2013")
                    {
                        provisionLiv = sumLivVuxen * (1 - 0.115);
                    }
                }
                if (r.provisionOvrig != null)
                {
                    provionOvrig = provionOvrig + (double)r.provisionOvrig;
                }

            }
            summaackvarden = sumBarn + sumVuxen;
            foreach (Provision a in p)
            {
                if (abc == "2012" && summaackvarden >= (double)a.totMinackVärde && summaackvarden <= (double)a.totMaxackVärde)
                {
                    provisionSO = ((sumBarn * Convert.ToDouble(a.provisionAndelBarn)) + (sumVuxen * (double)a.provisionAndelVuxen)) * (1 - 0.107);
                }
                if (abc == "2013" && summaackvarden >= (double)a.totMinackVärde && summaackvarden <= (double)a.totMinackVärde)
                {
                    provisionSO = ((sumBarn * Convert.ToDouble(a.provisionAndelBarn)) + (sumVuxen * (double)a.provisionAndelVuxen)) * (1 - 0.115);
                }
            }

            semesterersattning = provisionLiv + provionOvrig + provisionSO;

            if (abc == "2012")
            {
                semesterersattning = semesterersattning * 0.12;
                semesterprocent = "12%";
            }
            if (abc == "2013")
            {
                semesterersattning = semesterersattning * 0.13;
                semesterprocent = "13%";
            }

            summaprov = provisionSO + provisionLiv + provionOvrig + semesterersattning;

            Anstalld ans = databashantering.HamtaAnstalldViaAgentNr(agenturNr);
            skatt = summaprov * (double)ans.skattesats;
            anstalldskattesats = (double)ans.skattesats;

            attUtbetala = summaprov - skatt;
        }

        public string year;
        public string månad;
        public decimal medel;
        public decimal sumJan, sumFeb, sumMar, sumApr, sumMaj, sumJun, sumJul, sumAgu, sumSep, sumOkt, sumNov, sumDec;
        public decimal vJan, vFeb, vMar, vApr, vMaj, vJun, vJul, vAgu, vSep, vOkt, vNov, vDec;
        public decimal bJan, bFeb, bMar, bApr, bMaj, bJun, bJul, bAgu, bSep, bOkt, bNov, bDec;
        public decimal total;

        

        public void RäknaStatistik(int agenturnr)
        {
            List<Forsakring> b = databashantering.HamtaStatistikBarn(agenturnr);
            List<Forsakring> v = databashantering.HamtaStatistikVuxen(agenturnr);

            year = DateTime.Now.Year.ToString();
            
            foreach (Forsakring a in v)
            {
                månad = a.betaldDatum.Value.Month.ToString();
                if (year == "2012" && månad == "1")
                {
                    vJan = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "2")
                {
                    vFeb = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "3")
                {
                    vMar = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "4")
                {
                    vApr = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "5")
                {
                    vMaj = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "6")
                {
                    vJun = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "7")
                {
                    vJul = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "8")
                {
                    vAgu = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "9")
                {
                    vSep = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "10")
                {
                    vOkt = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "11")
                {
                    vNov = (decimal)a.grundbelopp;
                }
                if (year == "2012" && månad == "12")
                {
                    vDec = (decimal)a.grundbelopp;
                }
             }
            foreach (Forsakring a in b)
            {
                
            månad = a.betaldDatum.Value.Month.ToString();

            if (year == "2012" && månad == "1")
            {
                bJan = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "2")
            {
                bFeb = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "3")
            {
                bMar = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "4")
            {
                bApr = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "5")
            {
                bMaj = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "6")
            {
                bJun = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "7")
            {
                bJul = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "8")
            {
                bAgu = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "9")
            {
                 bSep = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "10")
            {
                bOkt = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "11")
            {
                bNov = (decimal)a.grundbelopp;
            }
            if (year == "2012" && månad == "12")
            {
                bDec = (decimal)a.grundbelopp;
            }
            
            sumJan = vJan + bJan; 
            sumFeb = vFeb + bFeb; 
            sumMar = vMar + bMar; 
            sumApr = vApr + bApr; 
            sumMaj = vMaj + bMaj; 
            sumJun = vJun + bJun;
            sumJul = vJul + bJul; 
            sumAgu = vAgu + bAgu; 
            sumSep = vSep + bSep; 
            sumOkt = vOkt + bOkt; 
            sumNov = vNov + bNov;
            sumDec = vDec + bDec;
            total = sumJan + sumFeb + sumMar + sumApr + sumMaj + sumJun + sumJul + sumAgu + sumSep + sumOkt + sumNov + sumDec;
            medel = total / 12;
            }

        }           
            
       
    }
}
               


